Jest: Mustahkam Dasturiy Ta'minot uchun Ilg'or Testlash Andozalari

            // component.js
export const fetchData = () => {
  // API so'rovini simulyatsiya qiladi
  return Promise.resolve({ data: 'some data' });
};

export const processData = async (fetcher) => {
  const result = await fetcher();
  return `Qayta ishlandi: ${result.data}`;
};

// component.test.js
import { processData } from './component';

test('ma\'lumotlarni to\'g\'ri qayta ishlashi kerak', async () => {
  const mockFetcher = jest.fn().mockResolvedValue({ data: 'mocked data' });
  const result = await processData(mockFetcher);
  expect(result).toBe('Qayta ishlandi: mocked data');
  expect(mockFetcher).toHaveBeenCalledTimes(1);
  expect(mockFetcher).toHaveBeenCalledWith();
});
            

              
                Copy
              
            
          

            // logger.js
export const logInfo = (message) => {
  console.log(`INFO: ${message}`);
};

// service.js
import { logInfo } from './logger';

export const performTask = (taskName) => {
  logInfo(`Vazifa boshlanmoqda: ${taskName}`);
  // ... vazifa mantig'i ...
  logInfo(`Vazifa ${taskName} yakunlandi.`);
};

// service.test.js
import { performTask } from './service';
import * as logger from './logger';

test('vazifaning boshlanishi va yakunlanishini logga yozishi kerak', () => {
  const logSpy = jest.spyOn(logger, 'logInfo');

  performTask('backup');

  expect(logSpy).toHaveBeenCalledTimes(2);
  expect(logSpy).toHaveBeenCalledWith('Vazifa boshlanmoqda: backup');
  expect(logSpy).toHaveBeenCalledWith('Vazifa backup yakunlandi.');

  logSpy.mockRestore(); // Asl implementatsiyani tiklash muhim
});
            

              
                Copy
              
            
          

            // api.js
import axios from 'axios';

export const getUser = async (userId) => {
  const response = await axios.get(`/api/users/${userId}`);
  return response.data;
};

// user-service.js
import { getUser } from './api';

export const getUserFullName = async (userId) => {
  const user = await getUser(userId);
  return `${user.firstName} ${user.lastName}`;
};

// user-service.test.js
import { getUserFullName } from './user-service';
import * as api from './api';

// Butun api modulini soxtalashtirish
jest.mock('./api');

test('soxtalashtirilgan API yordamida to\'liq ismni olishi kerak', async () => {
  // Soxtalashtirilgan moduldan ma'lum bir funksiyani soxtalashtirish
  api.getUser.mockResolvedValue({ id: 1, firstName: 'Ada', lastName: 'Lovelace' });

  const fullName = await getUserFullName(1);

  expect(fullName).toBe('Ada Lovelace');
  expect(api.getUser).toHaveBeenCalledTimes(1);
  expect(api.getUser).toHaveBeenCalledWith(1);
});
            

              
                Copy
              
            
          

            // math.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

// calculator.js
import { add, subtract } from './math';

export const calculate = (operation, a, b) => {
  if (operation === 'add') {
    return add(a, b);
  } else if (operation === 'subtract') {
    return subtract(a, b);
  }
  return null;
};

// calculator.test.js
import { calculate } from './calculator';
import * as math from './math';

// Butun math modulini soxtalashtirish
jest.mock('./math');

test('soxtalashtirilgan math add yordamida qo\'shishni bajarishi kerak', () => {
  // 'add' funksiyasi uchun mock implementatsiyasini taqdim etish
  math.add.mockImplementation((a, b) => a + b + 10); // Natijaga 10 qo'shish
  math.subtract.mockReturnValue(5); // subtract'ni ham soxtalashtirish

  const result = calculate('add', 5, 3);

  expect(math.add).toHaveBeenCalledWith(5, 3);
  expect(result).toBe(18); // 5 + 3 + 10

  const subResult = calculate('subtract', 10, 2);
  expect(math.subtract).toHaveBeenCalledWith(10, 2);
  expect(subResult).toBe(5);
});
            

              
                Copy
              
            
          

            // UserProfile.js
import React from 'react';

const UserProfile = ({ name, email, isActive }) => (
  <div>
    <h2>{name}</h2>
    <p><strong>Email:</strong> {email}</p>
    <p><strong>Status:</strong> {isActive ? 'Faol' : 'Nofaol'}</p>
  </div>
);

export default UserProfile;

// UserProfile.test.js
import React from 'react';
import renderer from 'react-test-renderer'; // React komponent snapshotlari uchun
import UserProfile from './UserProfile';

test('UserProfile to\'g\'ri render qilinadi', () => {
  const user = {
    name: 'Jane Doe',
    email: 'jane.doe@example.com',
    isActive: true,
  };
  const component = renderer.create(
    <UserProfile {...user} />
  );
  const tree = component.toJSON();
  expect(tree).toMatchSnapshot();
});

test('nofaol UserProfile to\'g\'ri render qilinadi', () => {
  const user = {
    name: 'John Smith',
    email: 'john.smith@example.com',
    isActive: false,
  };
  const component = renderer.create(
    <UserProfile {...user} />
  );
  const tree = component.toJSON();
  expect(tree).toMatchSnapshot('nofaol foydalanuvchi profili'); // Nomlangan snapshot
});
            

              
                Copy
              
            
          

            // jest.setup.js

expect.extend({
  toBeValidEmail(received) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    const pass = emailRegex.test(received);

    if (pass) {
      return {
        message: () => `kutilgan ${received} to\'g\'ri email bo\'lmasligi kerak edi`,
        pass: true,
      };
    } else {
      return {
        message: () => `kutilgan ${received} to\'g\'ri email bo\'lishi kerak edi`,
        pass: false,
      };
    }
  },
});

// jest.config.js faylingizda
// module.exports = { setupFilesAfterEnv: ['/jest.setup.js'] };
            

              
                Copy
              
            
          

            // validation.test.js

test('email formatlarini tasdiqlashi kerak', () => {
  expect('test@example.com').toBeValidEmail();
  expect('invalid-email').not.toBeValidEmail();
  expect('another.test@sub.domain.co.uk').toBeValidEmail();
});
            

              
                Copy
              
            
          

            // dataService.js
export const fetchUserData = async (userId) => {
  // Ma'lumotlarni kechikish bilan olishni simulyatsiya qilish
  await new Promise(resolve => setTimeout(resolve, 50));
  if (userId === 1) {
    return { id: 1, name: 'Alice' };
  } else {
    throw new Error('Foydalanuvchi topilmadi');
  }
};

// dataService.test.js
import { fetchUserData } from './dataService';

test('foydalanuvchi ma\'lumotlarini to\'g\'ri oladi', async () => {
  const user = await fetchUserData(1);
  expect(user).toEqual({ id: 1, name: 'Alice' });
});

test('mavjud bo\'lmagan foydalanuvchi uchun xatolik chiqaradi', async () => {
  await expect(fetchUserData(2)).rejects.toThrow('Foydalanuvchi topilmadi');
});
            

              
                Copy
              
            
          

            // dataService.test.js (davomi)

test('foydalanuvchi ma\'lumotlarini .resolves bilan oladi', () => {
  return expect(fetchUserData(1)).resolves.toEqual({ id: 1, name: 'Alice' });
});

test('mavjud bo\'lmagan foydalanuvchi uchun .rejects bilan xatolik chiqaradi', () => {
  return expect(fetchUserData(2)).rejects.toThrow('Foydalanuvchi topilmadi');
});
            

              
                Copy
              
            
          

            // delayedGreeter.js
export const greetAfterDelay = (name, callback) => {
  setTimeout(() => {
    callback(`Salom, ${name}!`);
  }, 1000);
};

// delayedGreeter.test.js
import { greetAfterDelay } from './delayedGreeter';

jest.useFakeTimers(); // Soxta taymerlarni yoqish

test('kechikishdan keyin salom beradi', () => {
  const mockCallback = jest.fn();
  greetAfterDelay('Dunyo', mockCallback);

  // Taymerlarni 1000ms oldinga surish
  jest.advanceTimersByTime(1000);

  expect(mockCallback).toHaveBeenCalledTimes(1);
  expect(mockCallback).toHaveBeenCalledWith('Salom, Dunyo!');
});

// Agar boshqa joyda kerak bo'lsa, haqiqiy taymerlarni tiklash
jest.useRealTimers();
            

              
                Copy
              
            
          

            describe('Foydalanuvchi Autentifikatsiya Servisi', () => {
  let authService;

  beforeEach(() => {
    // Har bir testdan oldin mock'larni yoki servis nusxalarini sozlash
    authService = require('./authService');
    jest.spyOn(authService, 'login').mockImplementation(() => Promise.resolve({ token: 'fake_token' }));
  });

  afterEach(() => {
    // Mock'larni tozalash
    jest.restoreAllMocks();
  });

  describe('login funksionalligi', () => {
    it('to\'g\'ri ma\'lumotlar bilan foydalanuvchini muvaffaqiyatli tizimga kiritishi kerak', async () => {
      const result = await authService.login('user@example.com', 'password123');
      expect(result.token).toBeDefined();
      // ... ko'proq tasdiqlar ...
    });

    it('noto\'g\'ri ma\'lumotlar bilan tizimga kirishda xatolikka uchrashi kerak', async () => {
      jest.spyOn(authService, 'login').mockRejectedValue(new Error('Noto\'g\'ri ma\'lumotlar'));
      await expect(authService.login('user@example.com', 'wrong_password')).rejects.toThrow('Noto\'g\'ri ma\'lumotlar');
    });
  });

  describe('logout funksionalligi', () => {
    it('foydalanuvchi sessiyasini tozalashi kerak', async () => {
      // Chiqish mantig'ini testlash...
    });
  });
});
            

              
                Copy
              
            
          

            // dateUtils.js
export const formatLocalizedDate = (date, locale) => {
  return new Intl.DateTimeFormat(locale, { year: 'numeric', month: 'numeric', day: 'numeric' }).format(date);
};

// dateUtils.test.js
import { formatLocalizedDate } from './dateUtils';

test('AQSh lokali uchun sanani to\'g\'ri formatlaydi', () => {
  const date = new Date(2023, 10, 15); // 2023-yil 15-noyabr
  expect(formatLocalizedDate(date, 'en-US')).toBe('11/15/2023');
});

test('Germaniya lokali uchun sanani to\'g\'ri formatlaydi', () => {
  const date = new Date(2023, 10, 15);
  expect(formatLocalizedDate(date, 'de-DE')).toBe('15.11.2023');
});
            

              
                Copy
              
            
          

            // apiService.js
import axios from 'axios';

const API_BASE_URL = 'https://api.example.com';

export const createProduct = async (productData) => {
  const response = await axios.post(`${API_BASE_URL}/products`, productData);
  return response.data;
};

// apiService.test.js (Integratsion test)
import axios from 'axios';
import { createProduct } from './apiService';

// Tarmoq qatlamini nazorat qilish uchun integratsion testlarda axios'ni soxtalashtirish
jest.mock('axios');

test('API orqali mahsulot yaratadi', async () => {
  const mockProduct = { id: 1, name: 'Gadget' };
  const responseData = { success: true, product: mockProduct };

  axios.post.mockResolvedValue({
    data: responseData,
    status: 201,
    headers: { 'content-type': 'application/json' },
  });

  const newProductData = { name: 'Gadget', price: 99.99 };
  const result = await createProduct(newProductData);

  expect(axios.post).toHaveBeenCalledWith(`${process.env.API_BASE_URL || 'https://api.example.com'}/products`, newProductData);
  expect(result).toEqual(responseData);
});
            

              
                Copy
              
            
          

            jest --coverage
            

              
                Copy